package com.chuangsi.common.utils;

import lombok.extern.slf4j.Slf4j;

import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 * @author wangshengming
 * @date 2023/10/27
 */
@Slf4j
public class PicExportUtil {

    /**
     * 下载压缩文件
     *
     * @param data    数据集合【key：分类名称，value：照片信息集合（key：照片名称，value:照片下载路径）】
     * @param fileStr 照片存放的文件路径
     */
    public static void downloadZipFile(Map<String, Map<String, Object>> data, HttpServletResponse response, String fileStr) {
        try {
            long timeMillis = System.currentTimeMillis();
            // 创建一个file实例对象，指向文件路径（存放照片的根目录）
            File rootFile = new File(fileStr);
            // 创建根目录【必须实际创建文件夹，否则会在new FileOutputStream(imgFile)创建流时会报错：java.io.FileNotFoundException: C:\Users\******\temp\image1635490490475\中秋\第二张图片.jpg (系统找不到指定的路径。)】
            if (!rootFile.exists()) {
                // 创建新文件夹，可以多层（mkdir()创建新文件夹，只能创建一层）
                rootFile.mkdirs();
            }
            log.info("图片map为" + data);
            // 将照片分类到不同目录
            for (Map.Entry<String, Map<String, Object>> dataMap : data.entrySet()) {
                // 指定父路径和文件路径，创建一个二级File对象【只是创建了实例对象，并没有实际创建该目录】
                File secondLevelFile = new File(rootFile, dataMap.getKey());
                if (!secondLevelFile.exists()) {
                    //这才是实际创建了
                    secondLevelFile.mkdirs();
                }
                // 下载照片到目录下
                for (Map.Entry<String, Object> imgsDataMap : dataMap.getValue().entrySet()) {
                    try {
                        //new一个URL对象
                        log.info("================" + "正在处理图片" + imgsDataMap.getValue() + "================");
                        URL url = new URL(imgsDataMap.getValue().toString());
                        //打开链接
                        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                        //设置请求方式为"GET"
                        conn.setRequestMethod("GET");
                        //超时响应时间为5秒
                        //通过输入流获取图片数据
                        InputStream inStream = conn.getInputStream();
                        log.info("================" + "处理图片结束" + imgsDataMap.getValue() + "================");
                        //得到图片的二进制数据，以二进制封装得到数据，具有通用性
                        byte[] bt = readInputStream(inStream);
                        //new一个file对象用来保存图片，保存在指定目录下
                        File imgFile = new File(secondLevelFile, imgsDataMap.getKey());
                        //创建输出流（new的jpg文件）【这一步才真的新建了文件】
                        try (FileOutputStream outStream = new FileOutputStream(imgFile)) {
                            //将照片二进制数据写入到new的ipg文件【这一步并不会真的写入，文件是0kb】
                            outStream.write(bt);
                            //try代码块结束时会调用close方法【这一步才会把数据写入到文件进去，因为close方法包含一次flush方法】
                        } catch (IOException e) {
                            throw new IOException(e);
                        }
                    } catch (Exception e) {
                    }
                }
            }
            response.setContentType("application/octet-stream");// 指明response的返回对象是文件流
            response.setHeader("Content-Disposition", "attachment;filename=" + timeMillis + ".zip");// 设置在下载框默认显示的文件名
            // 压缩法
            toZip1(rootFile, response, true);
            // 删除文件和压缩文件
            delFolder(fileStr);
            System.out.println("文件完成删除" + LocalDateTime.now());
            //delFolder(zipFileStr);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 压缩的递归方法
     *
     * @param sourceFile       源文件
     * @param zos              zip输出流
     * @param fileName         源文件的名称
     * @param keepDirStructure 是否保留原来的目录结构,true:保留目录结构;
     *                         false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
     */
    private static void compress(File sourceFile, ZipOutputStream zos, String fileName, boolean keepDirStructure) throws IOException {
        byte[] buf = new byte[2 * 1024];
        // 判断是否是一个文件
        if (sourceFile.isFile()) {
            // 向zip输出流中添加一个zip实体，构造器中name为zip实体的文件的名字
            zos.putNextEntry(new ZipEntry(fileName));
            // 创建文件（即某张图片）的输入流
            try (FileInputStream in = new FileInputStream(sourceFile)) {
                int len;
                // read方法：每调用一次就从FileInputStream流中读取一个字节，并返回下一个数据字节，若已到达末尾，就返回-1。
                while ((len = in.read(buf, 0, buf.length)) != -1) {
                    zos.write(buf, 0, len);
                }
                // 实际写入到了zip输出流的zip实体中，还没写到文件中【zip文件时0kb，不能打开，因为流没有关闭】
                zos.closeEntry();
            } catch (IOException e) {
                throw new IOException(e);
            }
        } else {
            // 源文件时目录
            // 获取该目录下所有文件和目录的绝对路径
            File[] listFiles = sourceFile.listFiles();
            // 空目录
            if (listFiles == null || listFiles.length == 0) {
                // 需要保留原来的文件结构时,需要对空文件夹进行处理
                if (keepDirStructure) {
                    // 空文件夹的处理
                    zos.putNextEntry(new ZipEntry(fileName + "/"));
                    // 没有文件，不需要文件的copy
                    zos.closeEntry();
                }
            } else {
                // 非空目录
                for (File file : listFiles) {
                    if (keepDirStructure) {
                        // 注意：getName()仅得到最后一层的名字，不是路径，所以要加“/”，不然所有文件都跑到压缩包根目录下了
                        compress(file, zos, fileName + "/" + file.getName(), true);
                    } else {
                        compress(file, zos, file.getName(), false);
                    }
                }
            }
        }
    }

    /**
     * 压缩成ZIP 方法1：保留多级目录结构
     *
     * @param sourceFile       照片存放路径
     * @param response         请求响应
     * @param keepDirStructure 是否保留原来的目录结构,true:保留目录结构;
     *                         false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
     */
    public static void toZip1(File sourceFile, HttpServletResponse response, boolean keepDirStructure) throws IOException {
        long start = System.currentTimeMillis();

        // 创建压缩输出流,java7的新语法：Try-with-resources，会确保异常抛出或者try代码块结束时close流【该流必须实现AutoCloseable类】（若是java7之前的版本，则不会生效）
        try (ZipOutputStream zos = new ZipOutputStream(response.getOutputStream())) {
            // 压缩
            compress(sourceFile, zos, sourceFile.getName(), keepDirStructure);
            long end = System.currentTimeMillis();
            System.out.println("压缩完成，耗时：" + (end - start) + " ms");
            System.out.println("压缩完成结束时间" + LocalDateTime.now());
        } catch (IOException e) {
            throw new IOException(e);
        }
    }

    /**
     * 压缩成ZIP 方法2：所有文件压缩到一个目录下
     *
     * @param srcFiles 需要压缩的文件列表
     * @param zos      压缩文件的输出流
     */
    public static void toZip2(List<File> srcFiles, ZipOutputStream zos) throws IOException {
        long start = System.currentTimeMillis();
        // 压缩文件的输出流
        for (File srcFile : srcFiles) {
            byte[] buf = new byte[2 * 1024];
            zos.putNextEntry(new ZipEntry(srcFile.getName()));
            try (FileInputStream in = new FileInputStream(srcFile)) {
                int len;
                while ((len = in.read(buf)) != -1) {
                    zos.write(buf, 0, len);
                }
                zos.closeEntry();
            } catch (IOException e) {
                throw new IOException(e);
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("压缩完成，耗时：" + (end - start) + " ms");
    }

    /**
     * 得到图片的二进制数据，以二进制封装得到数据，具有通用性
     *
     * @param inStream 输入流
     */
    private static byte[] readInputStream(InputStream inStream) throws IOException {
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        // 创建一个Buffer字符串
        byte[] buffer = new byte[1024];
        // 每次读取的字符串长度，如果为-1，代表全部读取完毕
        int len;
        // 使用一个输入流从buffer里把数据读取出来
        while ((len = inStream.read(buffer)) != -1) {
            // 用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度
            outStream.write(buffer, 0, len);
        }
        // 关闭输入流
        inStream.close();
        // 把outStream里的数据写入内存
        return outStream.toByteArray();
    }

    /**
     * 删除文件夹
     *
     * @param folderPath 文件夹完整绝对路径
     */
    public static void delFolder(String folderPath) {
        try {
            // 删除目录下所有内容
            delAllFile(folderPath);
            File myFilePath = new File(folderPath);
            //删除空文件夹
            myFilePath.delete();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 删除指定文件夹下所有文件
     *
     * @param path 文件夹完整绝对路径
     */
    public static boolean delAllFile(String path) {
        boolean bea = false;
        File file = new File(path);
        if (!file.exists()) {
            return bea;
        }
        if (!file.isDirectory()) {
            return bea;
        }
        //
        String[] tempList = file.list();
        File temp;
        if (tempList != null) {
            for (String var : tempList) {
                // separator 代替文件或文件夹路径的斜线或反斜线，防止跨平台出现错误
                if (path.endsWith(File.separator)) {
                    temp = new File(path + var);
                } else {
                    temp = new File(path + File.separator + var);
                }
                if (temp.isFile()) {
                    temp.delete();
                }
                if (temp.isDirectory()) {
                    //先删除文件夹里面的文件
                    delAllFile(path + "/" + var);
                    //再删除空文件夹
                    delFolder(path + "/" + var);
                    bea = true;
                }
            }
        }
        return bea;
    }

}
